#include <iostream>
using namespace std;

typedef long long LL;

const LL N = 100010;

LL n, m, p, ans, maxd, root;
LL pre[N], d[N], vis[N];

LL dfs(LL pos, LL dep)
{
    if (d[pos] || pos == root)
    {
        // 该节点访问过（送外卖走过）或者访问到了根节点
        // 更新最长外卖路径（因为最后不用返回所以要减去最长的那条）
        maxd = max(maxd, dep + d[pos]);
        return 2 * dep; // 总长度要加上原始点（新加入的点）到该点的长度的两倍（往返）
    }
    // 先递归到最远的那个没访问过的点，返回该点的dep*2
    // 每次要多走的路的长度是新加入的点到已经有的路的距离长度*2
    // 先递归才能算出这条路的长度（从新加入的点到最远的已访问的点的距离*2）
    LL add = dfs(pre[pos], dep + 1);
    // 再更新自己能到达的深度，是前一个点的深度+1
    d[pos] = d[pre[pos]] + 1; // 先递归，d[pre[pos]]才有值
    return add;
}

int main()
{
    cin >> n >> m;
    for (LL i = 1; i <= n; i++)
    {
        cin >> p;
        if (p == -1)
        {
            root = i;
        }
        pre[i] = p;
    }
    while (m--)
    {
        cin >> p;
        if (vis[p])
        {
            cout << ans - maxd << endl;
            continue;
        }
        vis[p] = true;
        ans += dfs(p, 0);
        cout << ans - maxd << endl;
    }
    return 0;
}

// 以下想法错了，无参考价值

// #include <iostream>
// #include <queue>
// #include <vector>
// #include <string.h>
// using namespace std;

// int n, m, root, ep;
// const int N = 1e5 + 7;
// int pre[N], dep[N];
// bool vis[N];

// struct WAY
// {
//     int dep, pos;
//     vector<int> nodes;
//     bool operator<(const WAY &w) const
//     {
//         return this->dep < w.dep;
//     }
// } ways[N];

// priority_queue<WAY> heap;

// struct EDGE
// {
//     int s, e;
//     EDGE *next;
// } edges[N];

// struct NODE
// {
//     EDGE *first;
// } nodes[N];

// void addedge(int s, int e)
// {
//     edges[ep].s = s;
//     edges[ep].e = e;
//     edges[ep].next = nodes[s].first;
//     nodes[s].first = &edges[ep];
//     ep++;
// }

// void dfs(int pos, vector<int> &ns)
// {
//     ways[pos].pos = pos;
//     ways[pos].dep = dep[pos];
//     ways[pos].nodes = ns;
//     EDGE *E = nodes[pos].first;
//     while (E != NULL)
//     {
//         ns.push_back(E->e);
//         dep[E->e] = dep[pos] + 1;
//         dfs(E->e, ns);
//         ns.pop_back();
//         E = E->next;
//     }
// }

// int main()
// {
//     cin >> n >> m;
//     for (int i = 1; i <= n; i++)
//     {
//         cin >> pre[i];
//         addedge(pre[i], i);
//         if (pre[i] == -1)
//         {
//             root = i;
//         }
//     }
//     dep[root] = 0;
//     vector<int> v;
//     dfs(root, v);
//     int ans = 0, maxd = 0;
//     for (int i = 0; i < m; i++)
//     {
//         int pos;
//         cin >> pos;
//         if (vis[pos])
//         {
//             cout << ans - maxd << endl;
//             continue;
//         }
//         heap.push(ways[pos]);
//         priority_queue<WAY> temp(heap);
//         memset(vis, false, sizeof(vis));
//         while (!temp.empty())
//         {
//             WAY w = temp.top();
//             temp.pop();
//             maxd = max(maxd, w.dep);
//             if (vis[w.pos])
//             {
//                 continue;
//             }
//             for (int i = 0; i < w.nodes.size(); i++)
//             {
//                 vis[w.nodes[i]] = true;
//             }
//             ans += 2 * w.dep;
//         }
//         cout << ans - maxd << endl;
//     }
//     return 0;
// }